package cn.mujiankeji.mbrowser.界面.小窗页.广告拦截

import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateListOf
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import cn.mujiankeji.mbrowser.app.应用接口
import cn.mujiankeji.mbrowser.功能.广告拦截.广告拦截操作
import cn.mujiankeji.mbrowser.功能.广告拦截.广告拦截订阅文件助手
import cn.mujiankeji.mbrowser.功能.广告拦截.项目.广告拦截订阅文件简介信息
import cn.mujiankeji.mbrowser.功能.广告拦截.项目.广告拦截订阅文件详情
import cn.mujiankeji.mbrowser.工具.mlog
import cn.mujiankeji.mbrowser.工具.网络.网络操作
import cn.mujiankeji.mbrowser.界面.框架.小窗视图.小窗状态
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch
import kotlinx.coroutines.withContext
import java.io.File

/**
 * 广告拦截规则管理窗口状态
 * 
 * 用于管理广告拦截规则，包括查看、添加、删除、启用/禁用规则
 */
class 广告拦截规则管理窗口状态 : 小窗状态() {
    
    // 规则订阅列表
    val 规则订阅列表 = mutableStateListOf<广告拦截订阅文件简介信息>()
    
    // 自定义规则文本
    var 自定义规则文本 by mutableStateOf("")
    
    // 当前编辑的规则
    var 当前编辑规则 by mutableStateOf<广告拦截订阅文件简介信息?>(null)
    
    // 新规则URL
    var 新规则URL by mutableStateOf("")
    
    // 加载状态
    var 正在加载 by mutableStateOf(false)
    var 加载错误信息 by mutableStateOf<String?>(null)
    
    // 当前选中的标签页
    var 当前标签页 by mutableStateOf(0) // 0: 订阅规则, 1: 自定义规则
    
    // 订阅文件助手
    private val 订阅文件助手 = 广告拦截订阅文件助手(广告拦截操作.读写锁)
    
    // 协程范围
    var coroutine: CoroutineScope? = null
    
    /**
     * 初始化函数
     * 加载现有规则
     */
    fun 初始化() {
        coroutine?.launch {
            正在加载 = true
            加载错误信息 = null
            
            try {
                
                // 加载订阅规则
                加载订阅规则()
                
                // 加载自定义规则
                加载自定义规则()
            } catch (e: Exception) {
                mlog("加载广告拦截规则失败", e)
                加载错误信息 = "加载规则失败: ${e.message}"
            } finally {
                正在加载 = false
            }
        }
    }
    
    /**
     * 加载订阅规则
     */
    private suspend fun 加载订阅规则() {
        val 规则列表 = withContext(Dispatchers.IO) {
            订阅文件助手.获取所有规则()
        }
        
        规则订阅列表.clear()
        规则订阅列表.addAll(规则列表)
    }
    
    /**
     * 加载自定义规则
     */
    private suspend fun 加载自定义规则() {
        val 自定义规则文件 = File(广告拦截操作.自定义规则路径)
        if (自定义规则文件.exists()) {
            自定义规则文本 = withContext(Dispatchers.IO) {
                自定义规则文件.readText()
            }
        } else {
            自定义规则文本 = ""
        }
    }
    
    /**
     * 保存自定义规则
     */
    fun 保存自定义规则() {
        coroutine?.launch {
            正在加载 = true
            try {
                withContext(Dispatchers.IO) {
                    val 自定义规则文件 = File(广告拦截操作.自定义规则路径)
                    自定义规则文件.parentFile?.mkdirs() // 确保目录存在
                    自定义规则文件.writeText(自定义规则文本)
                    
                    // 重新加载自定义规则到内存
                    val 自定义规则详情 = 广告拦截操作.读取规则文件详情("")
                    自定义规则详情?.从文本规则文件导入(广告拦截操作.自定义规则路径)
                }
                应用接口.输出提示("自定义规则已保存")
            } catch (e: Exception) {
                mlog("保存自定义规则失败", e)
                加载错误信息 = "保存失败: ${e.message}"
                应用接口.输出提示("保存失败: ${e.message}")
            } finally {
                正在加载 = false
            }
        }
    }
    
    /**
     * 添加规则订阅
     */
    fun 添加规则订阅() {
        if (新规则URL.isBlank()) {
            应用接口.输出提示("请输入订阅URL")
            return
        }
        
        coroutine?.launch {
            正在加载 = true
            加载错误信息 = null
            
            try {
                // 下载规则文件
                val 规则内容 = withContext(Dispatchers.IO) {
                    网络操作.获取文本(新规则URL)
                }
                
                if (规则内容.isNullOrBlank()) {
                    加载错误信息 = "下载规则失败，内容为空"
                    应用接口.输出提示("下载规则失败，内容为空")
                    return@launch
                }
                
                // 解析规则文件名称
                var 规则名称 = extractNameFromUrl(新规则URL)
                
                // 创建规则文件
                val 规则文件路径 = "${广告拦截操作.文件夹路径}${规则名称}.txt"
                withContext(Dispatchers.IO) {
                    val 规则文件 = File(规则文件路径)
                    规则文件.parentFile?.mkdirs() // 确保目录存在
                    规则文件.writeText(规则内容)
                }
                
                // 创建规则信息对象
                val 规则信息 = 广告拦截订阅文件简介信息(
                    name = 规则名称,
                    upurl = 新规则URL,
                    sign = "",
                    size = 规则内容.lines().count { it.isNotBlank() },
                    stop = false,
                    uptime = System.currentTimeMillis()
                )
                
                // 添加规则到配置文件
                val 新规则 = 订阅文件助手.添加规则(规则信息)
                
                // 更新内存中的规则
                广告拦截操作.规则文件列表.add(
                    广告拦截订阅文件详情(新规则.name)
                )
                
                // 刷新列表
                加载订阅规则()
                
                // 清空输入
                新规则URL = ""
                
                应用接口.输出提示("订阅规则已添加")
            } catch (e: Exception) {
                mlog("添加规则订阅失败", e)
                加载错误信息 = "添加失败: ${e.message}"
                应用接口.输出提示("添加失败: ${e.message}")
            } finally {
                正在加载 = false
            }
        }
    }
    
    /**
     * 更新规则订阅
     */
    fun 更新规则订阅(规则: 广告拦截订阅文件简介信息) {
        if (规则.upurl.isBlank()) {
            应用接口.输出提示("该规则没有更新地址")
            return
        }
        
        coroutine?.launch {
            正在加载 = true
            加载错误信息 = null
            
            try {
                // 下载规则文件
                val 规则内容 = withContext(Dispatchers.IO) {
                    网络操作.获取文本(规则.upurl)
                }
                
                if (规则内容.isNullOrBlank()) {
                    加载错误信息 = "更新规则失败，内容为空"
                    应用接口.输出提示("更新规则失败，内容为空")
                    return@launch
                }
                
                // 更新规则文件
                val 规则文件路径 = "${广告拦截操作.文件夹路径}${规则.name}.txt"
                withContext(Dispatchers.IO) {
                    val 规则文件 = File(规则文件路径)
                    规则文件.parentFile?.mkdirs() // 确保目录存在
                    规则文件.writeText(规则内容)
                }
                
                // 更新规则信息
                规则.size = 规则内容.lines().count { it.isNotBlank() }
                规则.uptime = System.currentTimeMillis()
                订阅文件助手.更新(规则)
                
                // 重新加载规则
                val 规则详情 = 广告拦截操作.读取规则文件详情(规则.name)
                规则详情?.从文本规则文件导入(规则文件路径)
                
                // 刷新列表
                加载订阅规则()
                
                应用接口.输出提示("规则已更新")
            } catch (e: Exception) {
                mlog("更新规则订阅失败", e)
                加载错误信息 = "更新失败: ${e.message}"
                应用接口.输出提示("更新失败: ${e.message}")
            } finally {
                正在加载 = false
            }
        }
    }
    
    /**
     * 删除规则订阅
     */
    fun 删除规则订阅(规则: 广告拦截订阅文件简介信息) {
        coroutine?.launch {
            正在加载 = true
            加载错误信息 = null
            
            try {
                // 从配置文件中删除规则
                val 删除成功 = 订阅文件助手.删除规则(规则.name)
                
                if (删除成功) {
                    // 删除规则文件
                    withContext(Dispatchers.IO) {
                        val 规则文件 = File("${广告拦截操作.文件夹路径}${规则.name}.txt")
                        val 规则文件夹 = File("${广告拦截操作.文件夹路径}${规则.name}")
                        规则文件.delete()
                        规则文件夹.deleteRecursively()
                    }
                    
                    // 从内存中移除规则
                    val 删除索引 = 广告拦截操作.规则文件列表.indexOfFirst { it.文件名称 == 规则.name }
                    if (删除索引 >= 0) {
                        广告拦截操作.规则文件列表.removeAt(删除索引)
                    }
                    
                    // 刷新列表
                    加载订阅规则()
                    
                    应用接口.输出提示("规则已删除")
                } else {
                    加载错误信息 = "删除规则失败"
                    应用接口.输出提示("删除规则失败")
                }
            } catch (e: Exception) {
                mlog("删除规则订阅失败", e)
                加载错误信息 = "删除失败: ${e.message}"
                应用接口.输出提示("删除失败: ${e.message}")
            } finally {
                正在加载 = false
            }
        }
    }
    
    /**
     * 切换规则启用状态
     */
    fun 切换规则启用状态(规则: 广告拦截订阅文件简介信息) {
        coroutine?.launch {
            正在加载 = true
            加载错误信息 = null
            
            try {
                // 切换规则状态
                规则.stop = !规则.stop
                订阅文件助手.更新状态(规则.name, 规则.stop)
                
                // 刷新列表
                加载订阅规则()
                

                
                val 状态文本 = if (规则.stop) "已停用" else "已启用"
                应用接口.输出提示("规则$状态文本")
            } catch (e: Exception) {
                mlog("切换规则状态失败", e)
                加载错误信息 = "操作失败: ${e.message}"
                应用接口.输出提示("操作失败: ${e.message}")
            } finally {
                正在加载 = false
            }
        }
    }
    
    /**
     * 从URL中提取规则名称
     */
    private fun extractNameFromUrl(url: String): String {
        val 文件名 = url.substringAfterLast('/', "rule")
            .substringBefore('.', "rule")
            .replace(Regex("[^a-zA-Z0-9_\\-]"), "_")
        
        return 文件名.ifEmpty { "rule" }
    }


} 